package com.movesti.android.app.quickcontact.activity;

import android.app.Activity;
import android.app.Dialog;
import android.content.ContentUris;
import android.content.Intent;
import android.content.SharedPreferences.Editor;
import android.database.Cursor;
import android.os.Bundle;
import android.provider.CallLog;
import android.provider.ContactsContract;
import android.provider.ContactsContract.Contacts;
import android.view.KeyEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.AdapterView.OnItemLongClickListener;
import android.widget.BaseAdapter;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.ListView;

import com.movester.quickcontact.R;
import com.movesti.android.app.quickcontact.EntryPointActivity;
import com.movesti.android.app.quickcontact.component.CallLogListAdapter;
import com.movesti.android.app.quickcontact.component.ContactPhotoLoader;
import com.movesti.android.app.quickcontact.component.FavoriteContactAdapter;
import com.movesti.android.app.quickcontact.helper.ListDialogHelper;
import com.movesti.android.app.quickcontact.helper.ListDialogHelper.ListDialogListener;
import com.movesti.android.app.quickcontact.query.AsyncJobHandler;
import com.movesti.android.app.quickcontact.query.IAsyncQueryJob;
import com.movesti.android.app.quickcontact.setting.CallLogSetting;
import com.movesti.android.app.quickcontact.setting.IChangeListener;
import com.movesti.android.app.quickcontact.setting.SettingChangeManager;
import com.movesti.android.app.quickcontact.setting.SettingManager;
import com.movesti.android.app.quickcontact.setting.SettingTemplate;
import com.movesti.android.app.quickcontact.util.PhoneUtil;
import com.movesti.android.app.quickcontact.util.SettingConfig;

public class CallLogActivity extends EmbeddableActivity implements OnClickListener, OnItemClickListener, OnItemLongClickListener, ListDialogListener, IChangeListener, IAsyncQueryJob {
    private ListView mList;
    private CallLogListAdapter mCallLogListAdapter;
    private FavoriteContactAdapter mFavoriteContactListAdapter;
    private Button mButtonCallLog, mButtonFavorite;
    private ImageView mButtonCallLogFilter;
    private CallLogSetting mSetting;
    private Dialog mCallFilterDialog;
    private ContactPhotoLoader mContactPhotoLoader;
    private boolean mListDisplayCalled = false;
    private boolean mNeedReloadOnResume = false;
    private AsyncJobHandler mAsyncJobHandler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.calllog);
        initComponents();
    }

    private void initComponents() {
        mSetting = SettingManager.getInstance(this).CallLogSetting;
        mList = (ListView) findViewById(R.id.list);
        mList.setOnItemClickListener(this);
        mButtonCallLog = (Button) findViewById(R.id.button_calllog);
        mButtonCallLog.setOnClickListener(this);
        mButtonFavorite = (Button) findViewById(R.id.button_favorite);
        mButtonFavorite.setOnClickListener(this);
        mButtonCallLogFilter = (ImageView) findViewById(R.id.button_filter);
        mButtonCallLogFilter.setOnClickListener(this);
        SettingChangeManager.getInstance().registerChangeListener(SettingChangeManager.ChangeSource_Global_GeneralSetting, this);
    }

    public final static class ColumnIndex {
        // common
        public final static int Id = 0;

        // call log query
        public final static int Cached_Name = 1;
        public final static int Number = 2;
        public final static int Date = 3;
        public final static int Duration = 4;
        public final static int Type = 5;

        // favorite query
        public final static int DisplayName = 1;
        public final static int ContactPhotoId = 2;
        public final static int HasPhone = 3;
        public final static int Starred = 4;
    }

    private final String[] CachedQueryArgs1 = new String[1];
    private final static String[] Projection_Call_Log = new String[] { CallLog.Calls._ID, CallLog.Calls.CACHED_NAME, CallLog.Calls.NUMBER, CallLog.Calls.DATE, CallLog.Calls.DURATION,
            CallLog.Calls.TYPE };
    private final static String CallLogFilterSql = CallLog.Calls.TYPE + "=?";

    private Cursor queryCallLog() {
        int i = mSetting.getCallLogCallLogFilterType();
        Cursor cursor;
        if (i == SettingConfig.CallLog_CallLog_Filter_Type_All) {
            cursor = getContentResolver().query(CallLog.Calls.CONTENT_URI, Projection_Call_Log, null, null, CallLog.Calls.DEFAULT_SORT_ORDER);
        } else {
            CachedQueryArgs1[0] = String.valueOf(i);
            cursor = getContentResolver().query(CallLog.Calls.CONTENT_URI, Projection_Call_Log, CallLogFilterSql, CachedQueryArgs1, CallLog.Calls.DEFAULT_SORT_ORDER);
        }
        return cursor;
    }

    private final static String[] Projection_Strequent_Call = new String[] { ContactsContract.Contacts._ID, Contacts.DISPLAY_NAME, ContactsContract.CommonDataKinds.Photo.PHOTO_ID,
            ContactsContract.Contacts.HAS_PHONE_NUMBER, ContactsContract.Contacts.STARRED };

    private final static String ContactListFilterSqlStarredOnly = ContactsContract.Contacts.STARRED + "=1";
    private final static String ContactListFilterSqlStarredOnlyOrderBy = ContactsContract.Contacts.DISPLAY_NAME + " asc";

    private final static String ContactListFilterSqlFrequentOnly = ContactsContract.Contacts.TIMES_CONTACTED + ">0";
    private final static String ContactListFilterSqlFrequentOnlyOrderBy = ContactsContract.Contacts.TIMES_CONTACTED + " desc";

    private final static String ContactListFilterSqlStarredAndFrequent = ContactsContract.Contacts.STARRED + "=1 or " + ContactsContract.Contacts.TIMES_CONTACTED + ">0";
    private final static String ContactListFilterSqlStarredAndFrequentOrderBy = ContactsContract.Contacts.STARRED + " desc ," + ContactsContract.Contacts.TIMES_CONTACTED + " desc";

    private Cursor queryContactList() {
        Cursor cursor = null;
        switch (mSetting.getContactListFilterType()) {
        case SettingConfig.Favorite_Filter_Type_Starred:
            cursor = getContentResolver().query(ContactsContract.Contacts.CONTENT_URI, Projection_Strequent_Call, ContactListFilterSqlStarredOnly, null, ContactListFilterSqlStarredOnlyOrderBy);
            break;
        case SettingConfig.Favorite_Filter_Type_Frequent:
            cursor = getContentResolver().query(ContactsContract.Contacts.CONTENT_URI, Projection_Strequent_Call, ContactListFilterSqlFrequentOnly, null, ContactListFilterSqlFrequentOnlyOrderBy);
            break;
        default:
            cursor = getContentResolver().query(ContactsContract.Contacts.CONTENT_URI, Projection_Strequent_Call, ContactListFilterSqlStarredAndFrequent, null,
                    ContactListFilterSqlStarredAndFrequentOrderBy);
            break;
        }
        return cursor;
    }

    private Cursor _previousCursor = null;

    private void displayTypeChanged() {
        if (_previousCursor != null) {
            stopManagingCursor(_previousCursor);
        }
        Cursor cursor = null;
        long displayType = mSetting.getCallLogDisplayType();
        if (displayType == SettingConfig.CallLog_Display_Type_Calllog) {
            cursor = queryCallLog();
            if (mCallLogListAdapter == null) {
                mCallLogListAdapter = new CallLogListAdapter(this, cursor);
                mList.setAdapter(mCallLogListAdapter);
            } else {
                mCallLogListAdapter.changeCursor(cursor);
            }
            mList.setAdapter(mCallLogListAdapter);
            mCallLogListAdapter.notifyDataSetChanged();
            mButtonCallLog.setEnabled(false);
            mButtonFavorite.setEnabled(true);
        } else if (displayType == SettingConfig.CallLog_Display_Type_Favorite_Contact) {
            cursor = queryContactList();
            if (mFavoriteContactListAdapter == null) {
                //                mContactPhotoLoader = new ContactPhotoLoader(this, R.drawable.calllog_contact_picture);
                //                mFavoriteContactListAdapter = new FavoriteContactListAdapter(this, cursor, mContactPhotoLoader);
            } else {
                //                mFavoriteContactListAdapter.changeCursor(cursor);
            }
            mList.setAdapter(mFavoriteContactListAdapter);
            mFavoriteContactListAdapter.notifyDataSetChanged();
            mButtonCallLog.setEnabled(true);
            mButtonFavorite.setEnabled(false);
        } else {
            return;
        }
        if (_previousCursor != null) {
            stopManagingCursor(_previousCursor);
        }
        _previousCursor = cursor;
        mList.setOnItemLongClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
        case R.id.button_dialog_close:
            mCallFilterDialog.dismiss();
            break;
        case R.id.button_calllog:
            mSetting.setCallLogDisplayType(SettingConfig.CallLog_Display_Type_Calllog);
            displayTypeChanged();
            break;
        case R.id.button_favorite:
            mSetting.setCallLogDisplayType(SettingConfig.CallLog_Display_Type_Favorite_Contact);
            displayTypeChanged();
            break;
        case R.id.button_filter:
            showDialog(Dialog_CallLogFilter);
            break;
        case R.id.calllog_filter_all:
            mSetting.setCallLogCallLogFilterType(SettingConfig.CallLog_CallLog_Filter_Type_All);
            syncCallLogDisplayDialogState();
            displayTypeChanged();
            mCallFilterDialog.dismiss();
            break;
        case R.id.calllog_filter_incoming:
            mSetting.setCallLogCallLogFilterType(SettingConfig.CallLog_CallLog_Filter_Type_Incoming);
            syncCallLogDisplayDialogState();
            displayTypeChanged();
            mCallFilterDialog.dismiss();
            break;
        case R.id.calllog_filter_outgoing:
            mSetting.setCallLogCallLogFilterType(SettingConfig.CallLog_CallLog_Filter_Type_Outgoing);
            syncCallLogDisplayDialogState();
            displayTypeChanged();
            mCallFilterDialog.dismiss();
            break;
        case R.id.calllog_filter_missed:
            mSetting.setCallLogCallLogFilterType(SettingConfig.CallLog_CallLog_Filter_Type_Missed);
            syncCallLogDisplayDialogState();
            displayTypeChanged();
            mCallFilterDialog.dismiss();
            break;
        case R.id.calllog_filter_contact_all:
            mSetting.setCallLogContactListFilterType(SettingConfig.CallLog_ContactList_Filter_Type_All);
            syncCallLogDisplayDialogState();
            displayTypeChanged();
            mCallFilterDialog.dismiss();
            break;
        case R.id.calllog_filter_starred:
            mSetting.setCallLogContactListFilterType(SettingConfig.Favorite_Filter_Type_Starred);
            syncCallLogDisplayDialogState();
            displayTypeChanged();
            mCallFilterDialog.dismiss();
            break;
        case R.id.calllog_filter_frequent:
            mSetting.setCallLogContactListFilterType(SettingConfig.Favorite_Filter_Type_Frequent);
            syncCallLogDisplayDialogState();
            displayTypeChanged();
            mCallFilterDialog.dismiss();
            break;
        }
    }

    private void syncCallLogDisplayDialogState() {
        if (mSetting.getCallLogDisplayType() == SettingConfig.CallLog_Display_Type_Calllog) {
            final int[] ids = new int[] { R.id.calllog_filter_all, R.id.calllog_filter_incoming, R.id.calllog_filter_missed, R.id.calllog_filter_outgoing };
            int disabledId = -1;
            switch (mSetting.getCallLogCallLogFilterType()) {
            case SettingConfig.CallLog_CallLog_Filter_Type_All:
                disabledId = R.id.calllog_filter_all;
                break;
            case SettingConfig.CallLog_CallLog_Filter_Type_Incoming:
                disabledId = R.id.calllog_filter_incoming;
                break;
            case SettingConfig.CallLog_CallLog_Filter_Type_Outgoing:
                disabledId = R.id.calllog_filter_outgoing;
                break;
            case SettingConfig.CallLog_CallLog_Filter_Type_Missed:
                disabledId = R.id.calllog_filter_missed;
                break;
            }
            if (disabledId != -1) {
                mCallFilterDialog.findViewById(disabledId).setEnabled(false);
                for (int i = 0; i < 4; i++) {
                    if (ids[i] != disabledId)
                        mCallFilterDialog.findViewById(ids[i]).setEnabled(true);
                }
            }
        } else if (mSetting.getCallLogDisplayType() == SettingConfig.CallLog_Display_Type_Favorite_Contact) {
            final int[] ids = new int[] { R.id.calllog_filter_contact_all, R.id.calllog_filter_frequent, R.id.calllog_filter_starred };
            int disabledId = -1;
            switch (mSetting.getContactListFilterType()) {
            case SettingConfig.CallLog_ContactList_Filter_Type_All:
                disabledId = R.id.calllog_filter_contact_all;
                break;
            case SettingConfig.Favorite_Filter_Type_Frequent:
                disabledId = R.id.calllog_filter_frequent;
                break;
            case SettingConfig.Favorite_Filter_Type_Starred:
                disabledId = R.id.calllog_filter_starred;
                break;
            }
            if (disabledId != -1) {
                mCallFilterDialog.findViewById(disabledId).setEnabled(false);
                for (int i = 0; i < 3; i++) {
                    if (ids[i] != disabledId)
                        mCallFilterDialog.findViewById(ids[i]).setEnabled(true);
                }
            }
        }
    }

    private final static int Dialog_CallLogFilter = 1;

    @Override
    protected Dialog onCreateDialog(int id) {
        switch (id) {
        case Dialog_CallLogFilter:
            Dialog d = new Dialog(this);
            d.setContentView(R.layout.calllog_dialog_filter);
            d.findViewById(R.id.calllog_filter_all).setOnClickListener(this);
            d.findViewById(R.id.calllog_filter_incoming).setOnClickListener(this);
            d.findViewById(R.id.calllog_filter_missed).setOnClickListener(this);
            d.findViewById(R.id.calllog_filter_outgoing).setOnClickListener(this);
            d.findViewById(R.id.calllog_filter_contact_all).setOnClickListener(this);
            d.findViewById(R.id.calllog_filter_starred).setOnClickListener(this);
            d.findViewById(R.id.calllog_filter_frequent).setOnClickListener(this);
            d.findViewById(R.id.button_dialog_close).setOnClickListener(this);
            mCallFilterDialog = d;
            return d;
        }
        return null;
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (mContactPhotoLoader != null)
            mContactPhotoLoader.stop();
        Editor editor = SettingManager.getInstance(this).getPrefEditor(this);
        mSetting.save(editor);
        editor.commit();
    }

    @Override
    protected void onResume() {
        super.onResume();
        if (isDisplayingCalllog() || mListDisplayCalled == false) {
            displayTypeChanged();
            mListDisplayCalled = true;
        }
        if (mNeedReloadOnResume == true) {
            mNeedReloadOnResume = false;
            changeTextSize();
        }
    }

    private boolean isDisplayingCalllog() {
        boolean r = false, isChild = isChild();
        final Intent intent = isChild ? getParent().getIntent() : getIntent();

        if (isChild == true && CallLogActivity.class.getCanonicalName().equals(intent.getStringExtra(EntryPointActivity.Extra_Target))) {
            if (intent.getIntExtra(EntryPointActivity.Extra_Arg1, -1) == SettingConfig.CallLog_Display_Type_Calllog) {
                r = true;
            }
        } else if (isChild == false) {
            r = true;
        }

        if (r == true) {
            // come to see missed call or call history
            if (mAsyncJobHandler == null) {
                mAsyncJobHandler = AsyncJobHandler.getInstance();
            }
            mAsyncJobHandler.startJob(this, null);
            mSetting.setCallLogDisplayType(SettingConfig.CallLog_Display_Type_Calllog);
            if (isChild == true) {
                if (intent.getBooleanExtra(EntryPointActivity.Extra_Ignore_State, false) == true) {
                    if (mList != null) {
                        mList.setSelection(0);
                    }
                }
                intent.removeExtra(EntryPointActivity.Extra_Target);
                intent.removeExtra(EntryPointActivity.Extra_Arg1);
                intent.removeExtra(EntryPointActivity.Extra_Ignore_State);
            }
        }
        return r;
    }

    @Override
    protected void onPrepareDialog(int id, Dialog dialog) {
        switch (id) {
        case Dialog_CallLogFilter:
            if (mSetting.getCallLogDisplayType() == SettingConfig.CallLog_Display_Type_Calllog) {
                View v = dialog.findViewById(R.id.calllog_panel);
                if (v.getVisibility() == View.VISIBLE) {
                    return;
                } else {
                    v.setVisibility(View.VISIBLE);
                    dialog.findViewById(R.id.contactlist_panel).setVisibility(View.GONE);
                }
                dialog.setTitle(R.string.dialog_title_calllog_filter);
            } else if (mSetting.getCallLogDisplayType() == SettingConfig.CallLog_Display_Type_Favorite_Contact) {
                View v = dialog.findViewById(R.id.contactlist_panel);
                if (v.getVisibility() == View.VISIBLE) {
                    return;
                } else {
                    v.setVisibility(View.VISIBLE);
                    dialog.findViewById(R.id.calllog_panel).setVisibility(View.GONE);
                }
                dialog.setTitle(R.string.dialog_title_contact_type_filter);
            }
        }
        syncCallLogDisplayDialogState();
    }

    @Override
    public void onItemClick(AdapterView<?> parent, View v, int position, long id) {
        if (v instanceof ViewGroup) {
            long idToView = -1;
            Object tag = v.getTag();
            if (tag instanceof CallLogListAdapter.ViewCache) {
                idToView = ((CallLogListAdapter.ViewCache) tag).contactId;
                Intent intent = new Intent(Intent.ACTION_VIEW);
                intent.setData(ContentUris.withAppendedId(CallLog.Calls.CONTENT_URI, idToView));
                intent.setClass(this, CallDetailActivity.class);
                startActivity(intent);
            } else if (tag instanceof FavoriteContactAdapter.ViewCache) {
                //                idToView = ((FavoriteContactListAdapter.ViewCache) tag).id;
                PhoneUtil.viewContactDetail(idToView, this);
            }
        }
    }

    @Override
    protected void onPause() {
        super.onPause();
    }

    @Override
    public boolean onItemLongClick(AdapterView<?> parent, View view, int position, long id) {
        final ListDialogHelper d = new ListDialogHelper(this);
        d.setOnItemSelectListener(this);
        if (mSetting.getCallLogDisplayType() == SettingConfig.CallLog_Display_Type_Calllog) {
            Cursor cursor = (Cursor) parent.getAdapter().getItem(position);
            String phoneNumber = cursor.getString(ColumnIndex.Number);
            long contactId = PhoneUtil.getContactIdByPhoneNumber(this, phoneNumber);
            if (PhoneUtil.getContactIdByPhoneNumber(this, phoneNumber) == -1) {
                // not a contact
                d.addDialogEntry(getResources().getString(R.string.dialog_entry_call_number, phoneNumber), R.string.dialog_entry_call_number);
                d.addDialogEntry(R.string.dialog_entry_dial_number).addDialogEntry(R.string.dialog_entry_sms).addDialogEntry(R.string.dialog_entry_add_to_contacts)
                        .addDialogEntry(R.string.dialog_entry_delete_call_log).addDialogEntry(R.string.dialog_entry_delete_all_by_number);
                d.setTitle(phoneNumber);
            } else {
                // already a contact
                d.addDialogEntry(getResources().getString(R.string.dialog_entry_call_number, phoneNumber), R.string.dialog_entry_call_number);
                d.addDialogEntry(R.string.dialog_entry_dial_number).addDialogEntry(R.string.dialog_entry_view_detail).addDialogEntry(R.string.dialog_entry_sms)
                        .addDialogEntry(R.string.dialog_entry_delete_call_log).addDialogEntry(R.string.dialog_entry_delete_all_by_name);
                if (PhoneUtil.getPhoneNumberByContactId(contactId, this).length > 1) {
                    d.addDialogEntry(R.string.dialog_entry_delete_all_by_number);
                }
                if (PhoneUtil.isFavoriteContactByContactId(this, contactId) == false)
                    d.addDialogEntry(R.string.dialog_entry_add_favorite);
                d.setTitle(cursor.getString(ColumnIndex.Cached_Name));
            }
        } else if (mSetting.getCallLogDisplayType() == SettingConfig.CallLog_Display_Type_Favorite_Contact) {
            Cursor cursor = (Cursor) parent.getAdapter().getItem(position);
            boolean hasPhone = cursor.getInt(ColumnIndex.HasPhone) != 0;
            d.addDialogEntry(R.string.dialog_entry_view_detail);
            if (hasPhone) {
                d.addDialogEntry(R.string.dialog_entry_call).addDialogEntry(R.string.dialog_entry_sms);
            }
            if (PhoneUtil.isFavoriteContactByContactId(this, cursor.getLong(ColumnIndex.Id))) {
                d.addDialogEntry(R.string.dialog_entry_remove_favorite);
            }
            d.addDialogEntry(R.string.dialog_entry_edit).addDialogEntry(R.string.dialog_entry_delete_contact);
            d.setTitle(cursor.getString(ColumnIndex.DisplayName));
        }
        d.getDialog().show();
        mList.setTag(position);
        return true;
    }

    @Override
    public void onDialogItemClicked(int tag) {
        Cursor cursor = (Cursor) mList.getAdapter().getItem((Integer) mList.getTag());
        String phoneNumber = null;
        long contactId = -1;
        boolean shouldReloadList = false;
        final int displayType = mSetting.getCallLogDisplayType();
        if (displayType == SettingConfig.CallLog_Display_Type_Calllog) {
            phoneNumber = cursor.getString(ColumnIndex.Number);
            contactId = PhoneUtil.getContactIdByPhoneNumber(this, phoneNumber);
        } else if (displayType == SettingConfig.CallLog_Display_Type_Favorite_Contact) {
            contactId = cursor.getInt(ColumnIndex.Id);
        }

        switch (tag) {
        case R.string.dialog_entry_call_number:
            // only in calllog
            PhoneUtil.callNumber(phoneNumber, this);
            break;
        case R.string.dialog_entry_dial_number:
            // only in calllog
            PhoneUtil.dialNumber(phoneNumber, this);
            break;
        case R.string.dialog_entry_call:
            // only in favorite
            PhoneUtil.callByContactId(contactId, this);
            break;
        case R.string.dialog_entry_sms:
            // both
            if (displayType == SettingConfig.CallLog_Display_Type_Calllog) {
                PhoneUtil.sendSms(phoneNumber, this);
            } else if (displayType == SettingConfig.CallLog_Display_Type_Favorite_Contact) {
                PhoneUtil.sendSmsByContactId(contactId, this);
            }
            break;
        case R.string.dialog_entry_add_to_contacts:
            // only in call log
            PhoneUtil.editOrAddNumber(phoneNumber, this);
            break;
        case R.string.dialog_entry_delete_call_log:
            // only in call log
            PhoneUtil.deleteCallLogByID(cursor.getString(ColumnIndex.Id), this);
            shouldReloadList = true;
            break;
        case R.string.dialog_entry_delete_all_by_number:
            // only in call log
            PhoneUtil.deleteCallLogByPhoneNumber(phoneNumber, this);
            shouldReloadList = true;
            break;
        case R.string.dialog_entry_view_detail:
            // both
            PhoneUtil.viewContactDetail(contactId, this);
            break;
        case R.string.dialog_entry_delete_all_by_name:
            // only in call log
            PhoneUtil.deleteCallLogByCachedContactName(cursor.getString(ColumnIndex.Cached_Name), this);
            shouldReloadList = true;
            break;
        case R.string.dialog_entry_add_favorite:
            // only in call log
            PhoneUtil.updateContactFavoriteByContactId(true, contactId, this);
            shouldReloadList = true;
            break;
        case R.string.dialog_entry_remove_favorite:
            // both
            PhoneUtil.updateContactFavoriteByContactId(false, contactId, this);
            shouldReloadList = true;
            break;
        case R.string.dialog_entry_delete_contact:
            // only in favorite
            String name = null;
            if (mSetting.getCallLogDisplayType() == SettingConfig.CallLog_Display_Type_Calllog) {
                name = cursor.getString(ColumnIndex.Cached_Name);
            } else if (mSetting.getCallLogDisplayType() == SettingConfig.CallLog_Display_Type_Favorite_Contact) {
                name = cursor.getString(ColumnIndex.DisplayName);
            }
            PhoneUtil.deleteContactByContactId(contactId, name, this);
            break;
        }
        if (shouldReloadList) {
            ((BaseAdapter) mList.getAdapter()).notifyDataSetChanged();
        }
    }

    private void changeTextSize() {
        ((BaseAdapter) mList.getAdapter()).notifyDataSetChanged();
    }

    @Override
    public void onChange(int changeSource, Object changeInfo) {
        if (changeSource == SettingChangeManager.ChangeSource_Global_GeneralSetting) {
            final Activity parent = getParent();
            if ((parent != null && CallLogActivity.class.getCanonicalName().equals(((EntryPointActivity) parent).getCurrentActiveComponentName())) || parent == null) {
                changeTextSize();
            } else {
                mNeedReloadOnResume = true;
            }
        }
    }

    @Override
    public Object doAsyncJob(Object arg) {
        PhoneUtil.clearNewCall(this);
        return null;
    }

    @Override
    public void asyncJobDone(Object result, Object arg) {
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if (keyCode == KeyEvent.KEYCODE_MENU) {
            if (isChild() == true) {
                SettingManager manager = SettingManager.getInstance(this);
                SettingActivity.startActivity(new SettingTemplate[] { manager.GlobalSetting }, this);
                return true;
            }
        }
        return super.onKeyDown(keyCode, event);
    }

    @Override
    public void onBecomeActive() {
        if (mNeedReloadOnResume == true) {
            mNeedReloadOnResume = false;
            changeTextSize();
        }
    }
}
